Analyzing Business Relations & Documents

class: title-slide

# ER018 - Analyzing Business Relations & Documents

## PVA1

### Arbeiten mit Zeichenketten (strings)

<br>
<br>
<br>
<br>
<br>
<br>
<br>
### FS 2024
<br>
### Prof. Dr. Jörg Schoder
.mycontacts[
<svg aria-hidden="true" role="img" viewBox="0 0 496 512" style="height:1em;width:0.97em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:currentColor;overflow:visible;position:relative;"><path d="M165.9 397.4c0 2-2.3 3.6-5.2 3.6-3.3.3-5.6-1.3-5.6-3.6 0-2 2.3-3.6 5.2-3.6 3-.3 5.6 1.3 5.6 3.6zm-31.1-4.5c-.7 2 1.3 4.3 4.3 4.9 2.6 1 5.6 0 6.2-2s-1.3-4.3-4.3-5.2c-2.6-.7-5.5.3-6.2 2.3zm44.2-1.7c-2.9.7-4.9 2.6-4.6 4.9.3 2 2.9 3.3 5.9 2.6 2.9-.7 4.9-2.6 4.6-4.6-.3-1.9-3-3.2-5.9-2.9zM244.8 8C106.1 8 0 113.3 0 252c0 110.9 69.8 205.8 169.5 239.2 12.8 2.3 17.3-5.6 17.3-12.1 0-6.2-.3-40.4-.3-61.4 0 0-70 15-84.7-29.8 0 0-11.4-29.1-27.8-36.6 0 0-22.9-15.7 1.6-15.4 0 0 24.9 2 38.6 25.8 21.9 38.6 58.6 27.5 72.9 20.9 2.3-16 8.8-27.1 16-33.7-55.9-6.2-112.3-14.3-112.3-110.5 0-27.5 7.6-41.3 23.6-58.9-2.6-6.5-11.1-33.3 2.6-67.9 20.9-6.5 69 27 69 27 20-5.6 41.5-8.5 62.8-8.5s42.8 2.9 62.8 8.5c0 0 48.1-33.6 69-27 13.7 34.7 5.2 61.4 2.6 67.9 16 17.7 25.8 31.5 25.8 58.9 0 96.5-58.9 104.2-114.8 110.5 9.2 7.9 17 22.9 17 46.4 0 33.7-.3 75.4-.3 83.6 0 6.5 4.6 14.4 17.3 12.1C428.2 457.8 496 362.9 496 252 496 113.3 383.5 8 244.8 8zM97.2 352.9c-1.3 1-1 3.3.7 5.2 1.6 1.6 3.9 2.3 5.2 1 1.3-1 1-3.3-.7-5.2-1.6-1.6-3.9-2.3-5.2-1zm-10.8-8.1c-.7 1.3.3 2.9 2.3 3.9 1.6 1 3.6.7 4.3-.7.7-1.3-.3-2.9-2.3-3.9-2-.6-3.6-.3-4.3.7zm32.4 35.6c-1.6 1.3-1 4.3 1.3 6.2 2.3 2.3 5.2 2.6 6.5 1 1.3-1.3.7-4.3-1.3-6.2-2.2-2.3-5.2-2.6-6.5-1zm-11.4-14.7c-1.6 1-1.6 3.6 0 5.9 1.6 2.3 4.3 3.3 5.6 2.3 1.6-1.3 1.6-3.9 0-6.2-1.4-2.3-4-3.3-5.6-2z"/></svg> @FFHS-EconomicResearch
<svg aria-hidden="true" role="img" viewBox="0 0 448 512" style="height:1em;width:0.88em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:currentColor;overflow:visible;position:relative;"><path d="M416 32H31.9C14.3 32 0 46.5 0 64.3v383.4C0 465.5 14.3 480 31.9 480H416c17.6 0 32-14.5 32-32.3V64.3c0-17.8-14.4-32.3-32-32.3zM135.4 416H69V202.2h66.5V416zm-33.2-243c-21.3 0-38.5-17.3-38.5-38.5S80.9 96 102.2 96c21.2 0 38.5 17.3 38.5 38.5 0 21.3-17.2 38.5-38.5 38.5zm282.1 243h-66.4V312c0-24.8-.5-56.7-34.5-56.7-34.6 0-39.9 27-39.9 54.9V416h-66.4V202.2h63.7v29.2h.9c8.9-16.8 30.6-34.5 62.9-34.5 67.2 0 79.7 44.3 79.7 101.9V416z"/></svg> @jfschoder
]

---
layout: true

<div style="position: absolute;left:400px;bottom:10px;font-size:9px"><svg aria-hidden="true" role="img" viewBox="0 0 496 512" style="height:1em;width:0.97em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:currentColor;overflow:visible;position:relative;"><path d="M245.83 214.87l-33.22 17.28c-9.43-19.58-25.24-19.93-27.46-19.93-22.13 0-33.22 14.61-33.22 43.84 0 23.57 9.21 43.84 33.22 43.84 14.47 0 24.65-7.09 30.57-21.26l30.55 15.5c-6.17 11.51-25.69 38.98-65.1 38.98-22.6 0-73.96-10.32-73.96-77.05 0-58.69 43-77.06 72.63-77.06 30.72-.01 52.7 11.95 65.99 35.86zm143.05 0l-32.78 17.28c-9.5-19.77-25.72-19.93-27.9-19.93-22.14 0-33.22 14.61-33.22 43.84 0 23.55 9.23 43.84 33.22 43.84 14.45 0 24.65-7.09 30.54-21.26l31 15.5c-2.1 3.75-21.39 38.98-65.09 38.98-22.69 0-73.96-9.87-73.96-77.05 0-58.67 42.97-77.06 72.63-77.06 30.71-.01 52.58 11.95 65.56 35.86zM247.56 8.05C104.74 8.05 0 123.11 0 256.05c0 138.49 113.6 248 247.56 248 129.93 0 248.44-100.87 248.44-248 0-137.87-106.62-248-248.44-248zm.87 450.81c-112.54 0-203.7-93.04-203.7-202.81 0-105.42 85.43-203.27 203.72-203.27 112.53 0 202.82 89.46 202.82 203.26-.01 121.69-99.68 202.82-202.84 202.82z"/></svg>Prof. Dr. Jörg Schoder</div>

---
name: agenda
class: left

.blockquote[Agenda]

## Arbeiten mit Zeichenketten (strings)

* (Sehr kurze) Einführung in R-Objekte

* Zeichenketten in Base-R und das stringr-Paket

* Regelhafte Ausdrücke (regular expressions)

* Fortgeschrittene reguläre Ausdrücke

---
class: left

.blockquote[Intro R-Objekte]

## R als objektorientierte Sprache

* Objekte lassen sich in Klassen einteilen
  * tibbles, data.frames
  * Vektoren
  * Funktionen

--
* Objekte sind vektorbasiert

--
* Variablentypen

--
  * logisch (`logical`)

--
  * numerisch
      * `integer`
      * `double`
--
  * kategorial
      * `character` (Zeichenketten, engl. strings)
      * `factor`

???

* logical: binäre Logik (true vs. false)
* numerisch: integer (ganze Zahlen), double (Doppelgleitkommazahlen)
* kategoriale Daten
  * strings (Zeichenketten)
  * factors für überschaubar viele Ausprägungen, die nich alphanumerisch geordnet werden sollen

---
class: inverse, center, middle

## Zeichenketten in Base-R

.blockquote[strings erzeugen]

.blockquote[strings verknüpfen]

.blockquote[strings zerlegen]

---
class: left

.blockquote[strings erzeugen]

## Eingabe mit Anführungzeichen

* Einfache Anführungszeichen

```r
"hoi!"
```

```
## [1] "hoi!"
```

* Doppelte Anführungszeichen

```r
'hoi!'
```

```
## [1] "hoi!"
```

* Problem: verschachtelte Anführungszeichen

```r
# Ich habe "hoi!" gesagt
"Ich habe "hoi!" gesagt."
```

```
## Error: <text>:2:12: unerwartetes Symbol
## 1: # Ich habe "hoi!" gesagt
## 2: "Ich habe "hoi
##               ^
```

---
class: left

.blockquote[strings erzeugen]

## Escape-Sequenz

* Verschachtelte Anführungszeichen: 
  * Variante 1 (`'`)

```r
'Ich habe "hoi!" gesagt.'
```

```
## [1] "Ich habe \"hoi!\" gesagt."
```
  
  * Variante 2 `\"` (Escape Sequenz!)

```r
"Ich habe \"hoi!\" gesagt."
```

```
## [1] "Ich habe \"hoi!\" gesagt."
```

---
class: left

.blockquote[strings erzeugen]

## Weitere Anwendungsfälle für Escape Sequenzen

* Neue Zeile: `\n`

```r
"Mit dem Pfeil, dem Bogen
Durch Gebirg und Tal
Kommt der Schütz gezogen
Früh am Morgenstrahl."
```

```
## [1] "Mit dem Pfeil, dem Bogen\nDurch Gebirg und Tal\nKommt der Schütz gezogen\nFrüh am Morgenstrahl."
```
* Unicode-Symbole ([Unicode-Chart](https://www.unicode.org/charts/)):
  * 8 Hexcode-Symbole: `\U`
  * 8 Hexcode-Symbole: `\u`

???

Escape sequences
You might have been surprised at the output from the last part of the last exercise. How did you get two lines from one string, and how did you get that little globe? The key is the \.

A sequence in a string that starts with a \ is called an escape sequence and allows us to include special characters in our strings. You saw one escape sequence in the first exercise: \" is used to denote a double quote.

In "hello\n\U1F30D" there are two escape sequences: \n gives a newline, and \U followed by up to 8 hex digits sequence denotes a particular Unicode character.

Unicode is a standard for representing characters that might not be on your keyboard. Each available character has a Unicode code point: a number that uniquely identifies it. These code points are generally written in hex notation, that is, using base 16 and the digits 0-9 and A-F. You can find the code point for a particular character by looking up a code chart. If you only need four digits for the codepoint, an alternative escape sequence is \u.

When R comes across a `\` it assumes you are starting an escape, so if you actually need a backslash in your string you'll need the sequence `\\`.

---
class: left

## Zahlenformate

.pull-left[
* `format()`: fix vs. wissenschaftlich

```r
x <- pi
x
```

```
## [1] 3.141593
```
]
--
.pull-right[
<br>

```r
format(x, scientific = TRUE)
```

```
## [1] "3.141593e+00"
```
]
--
.pull-left[
* `as.character()`

```r
as.character(x)
```

```
## [1] "3.14159265358979"
```
]

???

wissenschaftlich: `$3,1415*10^0$`

---
class: left

.blockquote[strings verknüpfen]

## `paste()`-Funktion

```r
hopp <- paste("H","O","P","P")
hopp
```

```
## [1] "H O P P"
```

```r
paste("H","O","P","P", sep = "-")
```

```
## [1] "H-O-P-P"
```

```r
paste(c("Hey","Ach","Mach"), "Du")
```

```
## [1] "Hey Du"  "Ach Du"  "Mach Du"
```
---
class: left

.blockquote[strings verknüpfen]

## Beispiel: Old MacDonald...

.panelset[
.panel[.panel-name[Funktion definieren]

```r
old_mac <- function(animal, animal_goes){
              eieio <- paste("E", "I", "E", "I", "O", sep = "-")
              old_mac <- "Old MacDonald had a farm"
              writeLines(c(
              old_mac,
              eieio,
              paste("And on his farm he had a", animal),
              eieio,
              paste(c("Here", "There", "Everywhere"), "a",
              c(animal_goes, animal_goes,
              paste(rep(animal_goes, 2), collapse = "-")),
              collapse = ", "),
              old_mac,
              eieio))
              }
```
.quellePanURL[Quelle: [C. Wickham, datacamp](https://app.datacamp.com/learn/courses/string-manipulation-with-stringr-in-r).]
]
.panel[.panel-name[Beispiel 1]

```r
old_mac("cow","moo")
```

```
## Old MacDonald had a farm
## E-I-E-I-O
## And on his farm he had a cow
## E-I-E-I-O
## Here a moo, There a moo, Everywhere a moo-moo
## Old MacDonald had a farm
## E-I-E-I-O
```
]
.panel[.panel-name[Beispiel 2]

```r
old_mac("dog","wolf")
```

```
## Old MacDonald had a farm
## E-I-E-I-O
## And on his farm he had a dog
## E-I-E-I-O
## Here a wolf, There a wolf, Everywhere a wolf-wolf
## Old MacDonald had a farm
## E-I-E-I-O
```
]
]

---
class: left

.blockquote[strings zerlegen]

## `strsplit()`-Funktion

.panelset[
.panel[.panel-name[Beispiele]

```r
strsplit(hopp,split = " ")
```

```
## [[1]]
## [1] "H" "O" "P" "P"
```
<svg aria-hidden="true" role="img" viewBox="0 0 512 512" style="height:1em;width:1em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:currentColor;overflow:visible;position:relative;"><path d="M256 512A256 256 0 1 0 256 0a256 256 0 1 0 0 512zm0-384c13.3 0 24 10.7 24 24V264c0 13.3-10.7 24-24 24s-24-10.7-24-24V152c0-13.3 10.7-24 24-24zM224 352a32 32 0 1 1 64 0 32 32 0 1 1 -64 0z"/></svg> Output ist eine Liste.

```r
test_dates<-c("24-03-2024","25-03-2024","26-03-2024","27-03-2024")
date_split <- strsplit(test_dates, split = "-")
class(date_split)
```

```
## [1] "list"
```

]
.panel[.panel-name[Listen]

* Anzahl Listen und Anzahl Elemente im ersten Teilobjekt

```r
length(date_split)
```

```
## [1] 4
```

```r
length(date_split[[1]])
```

```
## [1] 3
```

* Inhalt des ersten Teilobjekts der Liste

```r
date_split[1]
```

```
## [[1]]
## [1] "24"   "03"   "2024"
```
]
]

???

* arbeiten mit Listen ist eher kompliziert, daher empfiehlt es sich...

* ...Zerlegungen nicht mit der Base-R-Funktion strsplit() zu machen

* sondern auf tidyverse-Pakete zurückzugreifen
  * allgemein: stringr-Paket
  * speziell für Datumsangeben: lubridate
  
* bevor wir das stringr-Paket ausführlicher anschauen, ein kurzer Exkurs ins
lubridate-Paket

---
class: inverse, center, middle

## strings verarbeiten im tidyverse

.blockquote[Exkurs: lubridate für Datumsangaben]

.blockquote[stringr-Paket]

.blockquote[Beispiel: Vornamenhitparade CH]

---
class: left

.blockquote[Exkurs: lubridate für Datumsangaben]

## Verarbeitung von Datumsangaben im tidyverse

* **lubridate**-Bibliothek ist Teil des **tidyverse**-Metapakets

* Datumsobjekt erzeugen:

```r
library(tidyverse)
dates <- dmy(test_dates) # transformieren in Date-Objekt
```

--
* Zerlegung in Tag, Monat, Jahr

.pull-left[

```r
day(dates)
```

```
## [1] 24 25 26 27
```

```r
year(dates)
```

```
## [1] 2024 2024 2024 2024
```
]
--
.pull-right[

```r
month(dates)
```

```
## [1] 3 3 3 3
```

```r
month(dates,label = TRUE)
```

```
## [1] Mrz Mrz Mrz Mrz
## 12 Levels: Jan < Feb < Mrz < Apr < Mai < Jun < Jul < Aug < Sep < ... < Dez
```

]

???

* **lubridate**-Paket  mit speziellen Funktionen für Datumsangaben

---
class: left

.blockquote[stringr-Paket]

## Verarbeitung von Zeichenketten (strings) im **tidyverse**

.panelset[
.panel[.panel-name[Kurzüberblick]

* Aufbauend auf stringi

* Wird mit dem **tidyverse**-Metapaket automatisch geladen

* Als Teil des **tidyverse** leistungsstark und leicht zu erlernen

* Prägnant und konsistent: Alle Funktionen...

* beginnen mit `str_`

* nutzen als erstes Argument (Input) einen Vektor von Strings

* Ergebnisse werden in `tibble`-Objekten gespeichert und können direkt in **Pipes** weiterverarbeitet werden.
]
.panel[.panel-name[Vignette]
<iframe src="https://stringr.tidyverse.org/" width="100%" height="400px" data-external="1"></iframe>
]
]

---
class: left

.blockquote[Beispiel: Vornamenhitparade CH]

## Datenbasis

.panelset[
.panel[.panel-name[Datenquelle]
<img src="data:image/png;base64,#../../img/PVA1/BFS_20240408.PNG" width="70%" style="display: block; margin: auto;" />

.quellePanURL[<svg aria-hidden="true" role="img" viewBox="0 0 640 512" style="height:1em;width:1.25em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:currentColor;overflow:visible;position:relative;"><path d="M579.8 267.7c56.5-56.5 56.5-148 0-204.5c-50-50-128.8-56.5-186.3-15.4l-1.6 1.1c-14.4 10.3-17.7 30.3-7.4 44.6s30.3 17.7 44.6 7.4l1.6-1.1c32.1-22.9 76-19.3 103.8 8.6c31.5 31.5 31.5 82.5 0 114L422.3 334.8c-31.5 31.5-82.5 31.5-114 0c-27.9-27.9-31.5-71.8-8.6-103.8l1.1-1.6c10.3-14.4 6.9-34.4-7.4-44.6s-34.4-6.9-44.6 7.4l-1.1 1.6C206.5 251.2 213 330 263 380c56.5 56.5 148 56.5 204.5 0L579.8 267.7zM60.2 244.3c-56.5 56.5-56.5 148 0 204.5c50 50 128.8 56.5 186.3 15.4l1.6-1.1c14.4-10.3 17.7-30.3 7.4-44.6s-30.3-17.7-44.6-7.4l-1.6 1.1c-32.1 22.9-76 19.3-103.8-8.6C74 372 74 321 105.5 289.5L217.7 177.2c31.5-31.5 82.5-31.5 114 0c27.9 27.9 31.5 71.8 8.6 103.9l-1.1 1.6c-10.3 14.4-6.9 34.4 7.4 44.6s34.4 6.9 44.6-7.4l1.1-1.6C433.5 260.8 427 182 377 132c-56.5-56.5-148-56.5-204.5 0L60.2 244.3z"/></svg> [Download Rohdaten](https://www.bfs.admin.ch/bfs/de/home/statistiken/bevoelkerung/geburten-todesfaelle/vornamen-neugeborene.assetdetail.26565506.html).]

]
.panel[.panel-name[Datenimport]

* Aufbereitete Daten importieren

```r
my_in_file <- "BabynamesCH_(BFS_2024).rds"
tbl_babynames <- read_rds(xfun::from_root('data','tidy',my_in_file))
```

* Anzahl Beobachtungen

```r
tbl_babynames %>% 
            count()
```

```
## # A tibble: 1 × 1
##       n
##   <int>
## 1  2430
```

]
.panel[.panel-name[Daten]
* Einblick in die Tabelle (long-Format)

```r
head(tbl_babynames,7)
```

```
## # A tibble: 7 × 5
##   Vorname gender year   rank count
##   <chr>   <chr>  <chr> <dbl> <dbl>
## 1 Emma    girls  2022      1   361
## 2 Mia     girls  2022      2   356
## 3 Sofia   girls  2022      3   318
## 4 Emilia  girls  2022      4   292
## 5 Lina    girls  2022      5   289
## 6 Elena   girls  2022      6   280
## 7 Mila    girls  2022      7   267
```

]
]

---
class: left

.blockquote[Beispiel: Vornamenhitparade CH]

## Länge der Vornamen mit `str_length()`

```r
tbl_babynames %>% 
      group_by(year,gender) %>% 
      summarize(min=min(str_length(Vorname)),
                max=max(str_length(Vorname)),
                schnitt=mean(str_length(Vorname))) %>% head()
```

```
## # A tibble: 6 × 5
## # Groups:   year [3]
##   year  gender   min   max schnitt
##   <chr> <chr>  <int> <int>   <dbl>
## 1 2017  boys       3    10    5.03
## 2 2017  girls      3     9    5.01
## 3 2018  boys       3    10    5.03
## 4 2018  girls      3     9    5.01
## 5 2019  boys       3    10    5.03
## 6 2019  girls      3     9    5.01
```

???

str_length() gibt die Länge einer Zeichenfolge zurück, das heißt, die Anzahl der Zeichen in der Zeichenfolge.
Beispiel: str_length("banana") würde 6 zurückgeben, da "banana" sechs Zeichen lang ist.

---
class: left

.blockquote[Beispiel: Vornamenhitparade CH]

## Anzahl Zeichen in Vornamen mit `str_count()`

.panelset[
.panel[.panel-name[Einfach]

```r
tbl_babynames %>% 
      mutate(n_zeichen = str_count(Vorname)) %>% 
      head(5)
```

```
## # A tibble: 5 × 6
##   Vorname gender year   rank count n_zeichen
##   <chr>   <chr>  <chr> <dbl> <dbl>     <int>
## 1 Emma    girls  2022      1   361         4
## 2 Mia     girls  2022      2   356         3
## 3 Sofia   girls  2022      3   318         5
## 4 Emilia  girls  2022      4   292         6
## 5 Lina    girls  2022      5   289         4
```
]
.panel[.panel-name[Muster]

```r
tbl_babynames %>% 
      mutate(n_zeichen = str_count(Vorname, "m")) %>% 
      head(5)
```

```
## # A tibble: 5 × 6
##   Vorname gender year   rank count n_zeichen
##   <chr>   <chr>  <chr> <dbl> <dbl>     <int>
## 1 Emma    girls  2022      1   361         2
## 2 Mia     girls  2022      2   356         0
## 3 Sofia   girls  2022      3   318         0
## 4 Emilia  girls  2022      4   292         1
## 5 Lina    girls  2022      5   289         0
```
]
]

???

* Zahl der Zeichen im Vornamen kann auch mit `str_count()` ermittelt werden

* darüber hinaus bietet `str_count()` die Möglichkeit zum zählen der Anzahl der Vorkommen eines bestimmten **Musters** in einer Zeichenfolge.
Sie geben das Muster an, nach dem gesucht werden soll, und die Funktion gibt die Anzahl der Vorkommen dieses Musters in jeder Zeichenfolge zurück.
Wenn das Muster nicht gefunden wird, gibt str_count() 0 zurück.
Beispiel: str_count("banana", "a") würde 3 zurückgeben, da das Muster "a" drei Mal in "banana" vorkommt.

---
class: left

.blockquote[Beispiel: Vornamenhitparade CH]

## Teile von Vornamen extrahieren mit `str_sub()`

.panelset[
.panel[.panel-name[Erste 3 Buchstaben]

```r
tbl_babynames %>% 
  mutate(erste3 = str_sub(Vorname, 1, 3)) %>% 
  head()
```

```
## # A tibble: 6 × 6
##   Vorname gender year   rank count erste3
##   <chr>   <chr>  <chr> <dbl> <dbl> <chr> 
## 1 Emma    girls  2022      1   361 Emm   
## 2 Mia     girls  2022      2   356 Mia   
## 3 Sofia   girls  2022      3   318 Sof   
## 4 Emilia  girls  2022      4   292 Emi   
## 5 Lina    girls  2022      5   289 Lin   
## 6 Elena   girls  2022      6   280 Ele
```
]
.panel[.panel-name[Letzte 3 Buchstaben]

```r
tbl_babynames %>% 
  mutate(letzte3 = str_sub(Vorname, -3, -1)) %>% 
  head()
```

```
## # A tibble: 6 × 6
##   Vorname gender year   rank count letzte3
##   <chr>   <chr>  <chr> <dbl> <dbl> <chr>  
## 1 Emma    girls  2022      1   361 mma    
## 2 Mia     girls  2022      2   356 Mia    
## 3 Sofia   girls  2022      3   318 fia    
## 4 Emilia  girls  2022      4   292 lia    
## 5 Lina    girls  2022      5   289 ina    
## 6 Elena   girls  2022      6   280 ena
```
]
]

???

str_sub():

str_sub() wird verwendet, um Teilzeichenfolgen aus einer Zeichenfolge zu extrahieren.
Sie müssen Start- und Endindizes angeben, um den Teil der Zeichenfolge zu definieren, den Sie extrahieren möchten.
Das Ergebnis ist eine Teilzeichenfolge mit der Länge, die durch die angegebenen Start- und Endindizes definiert ist.
str_subset():

str_subset() wird verwendet, um eine Teilmenge von Zeichenfolgen zu extrahieren, die ein bestimmtes Muster erfüllen.
Sie müssen das Muster angeben, nach dem Sie suchen möchten.
Das Ergebnis ist eine Teilmenge der ursprünglichen Zeichenfolgen, die das angegebene Muster erfüllen.

---
class: left

.blockquote[Beispiel: Vornamenhitparade CH]

## Teile von Vornamen extrahieren mit `str_subset()`

```r
tbl_babynames %>%
  reframe(muster = str_subset(Vorname, pattern = "anna"))
```

```
## # A tibble: 24 × 1
##    muster 
##    <chr>  
##  1 Hanna  
##  2 Hannah 
##  3 Gianna 
##  4 Johanna
##  5 Hanna  
##  6 Hannah 
##  7 Gianna 
##  8 Johanna
##  9 Hanna  
## 10 Hannah 
## # ℹ 14 more rows
```

---
class: left

.blockquote[Beispiel: Vornamenhitparade CH]

## Teile von Vornamen extrahieren mit `str_extract()`

.panelset[
.panel[.panel-name[str_extract]

* `str_extract()` prüft die Zeichenfolgen auf das Muster...

* ...und gibt für Fälle, in denen das Muster nicht vorkommt "NA" aus

```r
tbl_babynames %>%
  reframe(muster = str_extract(Vorname, pattern = "anna")) %>% 
  head(3)
```

```
## # A tibble: 3 × 1
##   muster
##   <chr> 
## 1 <NA>  
## 2 <NA>  
## 3 <NA>
```

]
.panel[.panel-name[Auszählen]

```r
tbl_babynames %>%
  reframe(muster = str_extract(Vorname, pattern = "anna")) %>% 
  summarize(fehlende = sum(is.na(muster)),
            nicht_fehlende = sum(!is.na(muster)))
```

```
## # A tibble: 1 × 2
##   fehlende nicht_fehlende
##      <int>          <int>
## 1     2406             24
```

]
.panel[.panel-name[Unterschied]

* `str_subset()` gibt gesamte Zeichenkette aus, `str_extract()` nur das Muster

```r
tbl_babynames %>%
  reframe(muster = str_extract(Vorname, pattern = "anna")) %>% 
  filter(!is.na(muster)) %>% 
  head(4)
```

```
## # A tibble: 4 × 1
##   muster
##   <chr> 
## 1 anna  
## 2 anna  
## 3 anna  
## 4 anna
```
]
]

???

* Während `str_subset()` die gesamte Zeichenfolge ausgibt, die das Muster enthält...

* ...gibt `str_extract()` nur die gesuchte Zeichenkette aus

str_extract() ist ähnlich wie str_subset() in dem Sinne, dass es verwendet wird, um Zeichenfolgen zu extrahieren, die ein bestimmtes Muster erfüllen. Allerdings gibt es einen wesentlichen Unterschied:

str_subset(): Gibt die gesamte Teilzeichenfolge zurück, die das Muster erfüllt.
str_extract(): Gibt den ersten Teil der Zeichenfolge zurück, der das Muster erfüllt.

---
class: left

.blockquote[Beispiel: Vornamenhitparade CH]

## Muster in Vornamen finden mit `str_detect()`

.panelset[
.panel[.panel-name[einfach]
* Vornamen, die "tz" enthalten

```r
tbl_babynames  %>% 
      filter(str_detect(Vorname, pattern = "tz")) 
```

```
## # A tibble: 6 × 5
##   Vorname gender year   rank count
##   <chr>   <chr>  <chr> <dbl> <dbl>
## 1 Moritz  boys   2022    135    58
## 2 Moritz  boys   2021    130    70
## 3 Moritz  boys   2020    142    62
## 4 Moritz  boys   2019     99    87
## 5 Moritz  boys   2018    141    66
## 6 Moritz  boys   2017    127    74
```

]
.panel[.panel-name[kombiniert]

* Mädchennamen, die "sa" enthalten und mit "L" beginnen

```r
tbl_babynames %>%
  filter(str_detect(Vorname, pattern = "sa")) %>%
  mutate(muster = str_detect(Vorname, pattern = "L")) %>% 
  head(5)
```

```
## # A tibble: 5 × 6
##   Vorname gender year   rank count muster
##   <chr>   <chr>  <chr> <dbl> <dbl> <lgl> 
## 1 Elisa   girls  2022     38   143 FALSE 
## 2 Luisa   girls  2022     54   118 TRUE  
## 3 Lisa    girls  2022     82    83 TRUE  
## 4 Melissa girls  2022     84    81 FALSE 
## 5 Louisa  girls  2022    115    61 TRUE
```

]
]

---
class: left

.blockquote[Beispiel: Vornamenhitparade CH]

## Zeichenketten aufteilen `str_split()`

.panelset[
.panel[.panel-name[Voller Name]

```r
tbl_tmp <- tbl_babynames %>%
                mutate(Name = paste("Odermatt,", Vorname)) %>% 
                select(Name,gender,year,rank,count)
head(tbl_tmp)
```

```
## # A tibble: 6 × 5
##   Name             gender year   rank count
##   <chr>            <chr>  <chr> <dbl> <dbl>
## 1 Odermatt, Emma   girls  2022      1   361
## 2 Odermatt, Mia    girls  2022      2   356
## 3 Odermatt, Sofia  girls  2022      3   318
## 4 Odermatt, Emilia girls  2022      4   292
## 5 Odermatt, Lina   girls  2022      5   289
## 6 Odermatt, Elena  girls  2022      6   280
```

]
.panel[.panel-name[Aufsplitten]

```r
tbl_tmp %>%
    mutate(Nachname = str_split(Name, pattern = ", ", n = 2) %>% map_chr(1),
         Vorname = str_split(Name, pattern = ", ", n = 2) %>% map_chr(2)) %>% 
    head()
```

```
## # A tibble: 6 × 7
##   Name             gender year   rank count Nachname Vorname
##   <chr>            <chr>  <chr> <dbl> <dbl> <chr>    <chr>  
## 1 Odermatt, Emma   girls  2022      1   361 Odermatt Emma   
## 2 Odermatt, Mia    girls  2022      2   356 Odermatt Mia    
## 3 Odermatt, Sofia  girls  2022      3   318 Odermatt Sofia  
## 4 Odermatt, Emilia girls  2022      4   292 Odermatt Emilia 
## 5 Odermatt, Lina   girls  2022      5   289 Odermatt Lina   
## 6 Odermatt, Elena  girls  2022      6   280 Odermatt Elena
```
]
]

---
class: left

.blockquote[Beispiel: Vornamenhitparade CH]

## Zeichenketten modifizieren `str_replace()`

* (Sehr schmutzige) Alternative zu `str_split()`

* "Überschreiben" der Zeichenkette "Odermatt, " mit leerer Zeichenfolge ("")

```r
tbl_tmp %>%
    mutate(Vorname = str_replace(Name, pattern = "Odermatt,", "") %>% str_trim()) %>% 
  head()
```

```
## # A tibble: 6 × 6
##   Name             gender year   rank count Vorname
##   <chr>            <chr>  <chr> <dbl> <dbl> <chr>  
## 1 Odermatt, Emma   girls  2022      1   361 Emma   
## 2 Odermatt, Mia    girls  2022      2   356 Mia    
## 3 Odermatt, Sofia  girls  2022      3   318 Sofia  
## 4 Odermatt, Emilia girls  2022      4   292 Emilia 
## 5 Odermatt, Lina   girls  2022      5   289 Lina   
## 6 Odermatt, Elena  girls  2022      6   280 Elena
```
???

`str_trim()` muss verwendet werden, um führende und abschließende Leerzeichen zu entfernen, bevor die Daten ausgegeben werden können.

---
class: left

.blockquote[Beispiel: Vornamenhitparade CH]

## Typische Anwendungen für `str_replace()`

```r
test_dates
```

```
## [1] "24-03-2024" "25-03-2024" "26-03-2024" "27-03-2024"
```

```r
test_dates %>% 
      str_replace(pattern="-",".")
```

```
## [1] "24.03-2024" "25.03-2024" "26.03-2024" "27.03-2024"
```

```r
test_dates %>% 
      str_replace_all(pattern="-",".")
```

```
## [1] "24.03.2024" "25.03.2024" "26.03.2024" "27.03.2024"
```

---
class: left

.blockquote[Beispiel: Vornamenhitparade CH]

## Ausblick: Quantitative Textanalyse

.panelset[
.panel[.panel-name[Plot]
<img src="data:image/png;base64,#02_Intro_Strings_files/figure-html/unnamed-chunk-45-1.png" width="55%" style="display: block; margin: auto;" />
]
.panel[.panel-name[Code]

```r
anfangsbuchstabe <- tbl_babynames %>%
                        mutate(first_letter = substr(Vorname, 1, 1)) %>%
                        group_by(year,gender, first_letter) %>%
                        count()

anfangsbuchstabe %>%
  mutate(gender = factor(gender, levels = c("boys", "girls"))) %>%
  group_by(gender,year) %>%
  arrange(desc(n)) %>%
  slice_max(n=10,order_by = n) %>%
  ggplot(aes(x=first_letter,y=n,fill=fct_reorder(gender,n))) +
     geom_col(position = 'dodge') +
     facet_wrap(~fct_rev(year),scales = "free_x") +
     scale_fill_discrete(labels = c("girls" = "Mädchen", "boys" = "Knaben")) +
     labs(x='Anfangsbuchstabe',y='absolute Häufigkeit') + theme_light() +
     theme(legend.position = "bottom", legend.title = element_blank())  
```
]

]

---
class: inverse, center, middle

## Regelhafte Ausdrücke

.blockquote[Regelhafte Ausdrücke mit dem rebus-Paket]

.blockquote[Abwechselnde Zeichenfolgen (Alternations)]

.blockquote[Zeichenklassen (Character classes)]

.blockquote[Wiederholungen]

.blockquote[Abkürzungen]

---
class: left

.blockquote[Regelhafte Ausdrücke mit dem rebus-Paket]

## Regelhafte Ausdrücke

???

* regular expressions (regexp)

---
class: left

.blockquote[Regelhafte Ausdrücke mit dem rebus-Paket]

## Regelhafte Ausdrücke

* Übersicht

| Muster               | Regelmäßiger Ausdruck |   rebus    |
|----------------------|:---------------------:|:----------:|
| Beginn eines strings |          `^`          |  `START`   |
| Ende eines strings   |          `$`          |   `END`    |
| Einzelne Symbole     |          `.`          | `ANY_CHAR` |
| "Belegte" Symbole (`.`,`^`,`$`)|    `\.`,`\^`,`\$` | `DOT`,`CARAT`, `DOLLAR`|

* Besondere Muster regelhafte Ausdrücke
  * Alternative Zeichenfolgen (Alternations)
  * Zeichenklassen (character classes)
  * Wiederholungen

---
class: left

.blockquote[Alternative Zeichenfolgen]

## Unterschiedliche Kombinationen von Zeichenfolgen

`(winter|sommer)`

```r
library(stringr)
library(rebus)
or("Winter","Sommer")
```

```
## <regex> (?:Winter|Sommer)
```

```r
str_view(c("Sommer-Hitze","Traum-Winter","Traumwinter"),
  pattern = or("[Ww]inter","[Ss]ommer"),
  match=TRUE,html=TRUE)
```

<div class="str_view html-widget html-fill-item-overflow-hidden html-fill-item" id="htmlwidget-c93a3d578d0fa57e7306" style="width:960px;height:100%;"></div>
<script type="application/json" data-for="htmlwidget-c93a3d578d0fa57e7306">{"x":{"html":"<ul>\n  <li><pre><span class='match'>Sommer<\/span>-Hitze<\/pre><\/li>\n  <li><pre>Traum-<span class='match'>Winter<\/span><\/pre><\/li>\n  <li><pre>Traum<span class='match'>winter<\/span><\/pre><\/li>\n<\/ul>"},"evals":[],"jsHooks":[]}</script>
???

* Obs! Die erste Ausgabe unterscheidet sich leicht von der Eingabe: rebus ergänzt um `?:`, um anzuzeigen, dass es sich um eine "nicht-einfangende Gruppe" von Zeichen (non-capturing group) handelt. Dazu später mehr

---
class: left

.blockquote[Zeichenklassen (character classes)]

## Identifikation von (definierten) Symbolen

.pull-left[

```r
char_class("Aa")
```

```
## <regex> [Aa]
```

```r
str_view(c("Frankfurt","Freiheit","Effekt","Schifffahrt"),
          pattern = char_class("Ff"),html=TRUE
)
```

<div class="str_view html-widget html-fill-item-overflow-hidden html-fill-item" id="htmlwidget-0f7b0a8e955e35fd8924" style="width:960px;height:100%;"></div>
<script type="application/json" data-for="htmlwidget-0f7b0a8e955e35fd8924">{"x":{"html":"<ul>\n  <li><pre><span class='match'>F<\/span>rank<span class='match'>f<\/span>urt<\/pre><\/li>\n  <li><pre><span class='match'>F<\/span>reiheit<\/pre><\/li>\n  <li><pre>E<span class='match'>f<\/span><span class='match'>f<\/span>ekt<\/pre><\/li>\n  <li><pre>Schi<span class='match'>f<\/span><span class='match'>f<\/span><span class='match'>f<\/span>ahrt<\/pre><\/li>\n<\/ul>"},"evals":[],"jsHooks":[]}</script>
]
--
.pull-right[

```r
negated_char_class("Ff")
```

```
## <regex> [^Ff]
```

```r
str_view(c("Frankfurt","Freiheit","Effekt","Schifffahrt"),
          pattern = negated_char_class("Ff"),html=TRUE
)
```

<div class="str_view html-widget html-fill-item-overflow-hidden html-fill-item" id="htmlwidget-9deb0f8613f32b511ed4" style="width:960px;height:100%;"></div>
<script type="application/json" data-for="htmlwidget-9deb0f8613f32b511ed4">{"x":{"html":"<ul>\n  <li><pre>F<span class='match'>r<\/span><span class='match'>a<\/span><span class='match'>n<\/span><span class='match'>k<\/span>f<span class='match'>u<\/span><span class='match'>r<\/span><span class='match'>t<\/span><\/pre><\/li>\n  <li><pre>F<span class='match'>r<\/span><span class='match'>e<\/span><span class='match'>i<\/span><span class='match'>h<\/span><span class='match'>e<\/span><span class='match'>i<\/span><span class='match'>t<\/span><\/pre><\/li>\n  <li><pre><span class='match'>E<\/span>ff<span class='match'>e<\/span><span class='match'>k<\/span><span class='match'>t<\/span><\/pre><\/li>\n  <li><pre><span class='match'>S<\/span><span class='match'>c<\/span><span class='match'>h<\/span><span class='match'>i<\/span>fff<span class='match'>a<\/span><span class='match'>h<\/span><span class='match'>r<\/span><span class='match'>t<\/span><\/pre><\/li>\n<\/ul>"},"evals":[],"jsHooks":[]}</script>

]

???

* `char_class()` hilft alle Symbole zu finden
* Mit `negated_char_class()` können alle Symbole "außer" die angebebenen identifiziert werden.
  * dies wird in rebus durch das Carat `^`-Symbol innerhalb der eckigen Klammer angezeigt

---
class: left

.blockquote[Wiederholungen]

## Zeichenketten mit mehreren gleichartigen Symbolen/Mustern

* Übersicht

| Muster               | Regelmäßiger Ausdruck |   rebus    |
|----------------------|:---------------------:|:----------:|
| Optional             |          `?`          |  `optional()` |
| Null oder mehr       |          `*`          |   `zero_or_more()` |
| Eins oder mehr     |          `+`          | `one_or_more()` |
| Zwischen m- und n-mal |    `{m,n}` | `repeated()`|

* Beispiel

```r
str_view(c("Frankfurt","Freiheit","Effekt","Schifffahrt"),
         pattern = repeated("Ff",2,3),html=TRUE
         )
```

<div class="str_view html-widget html-fill-item-overflow-hidden html-fill-item" id="htmlwidget-6dd962ac82307bcb2964" style="width:960px;height:100%;"></div>
<script type="application/json" data-for="htmlwidget-6dd962ac82307bcb2964">{"x":{"html":"<ul>\n  <li><pre>E<span class='match'>ff<\/span>ekt<\/pre><\/li>\n  <li><pre>Schi<span class='match'>fff<\/span>ahrt<\/pre><\/li>\n<\/ul>"},"evals":[],"jsHooks":[]}</script>

---
class: left

.blockquote[Abkürzungen]

## Abgekürzte Eingabe regelhafter Ausdrücke

.pull-left[

* $-Symbol und Ziffer(n):

```r
DOLLAR %R% char_class("0123456789")
```

```
## <regex> \$[0123456789]
```
]
--
.pull-right[
* Eine Ziffer:

```r
char_class("0-9")
```

```
## <regex> [0-9]
```

]
--

.pull-left[
* Kleinbuchstaben

```r
char_class("a-z")
```

```
## <regex> [a-z]
```

]
--
.pull-right[

* Großbuchstaben

```r
char_class("A-Z")
```

```
## <regex> [A-Z]
```

]

---
class: left

.blockquote[Abkürzungen]

## Abgekürzte Eingabe regelhafter Ausdrücke

.pull-left[

* Ziffern

```r
DGT
```

```
## <regex> \d
```

]
--

.pull-right[
<br>

```r
char_class("0-9")
```

```
## <regex> [0-9]
```
]
--
.pull-left[

* Buchstaben

```r
WRD
```

```
## <regex> \w
```
]
--
.pull-right[
<br>

```r
char_class("a-zA-Z0-0_")
```

```
## <regex> [a-zA-Z0-0_]
```
]
--
.pull-left[
* Leerzeichen (Whitespace)

```r
SPC
```

```
## <regex> \s
```

]

---
class: inverse, center, middle

## Fortgeschrittene regelhafte Ausdrücke

.blockquote[Erfassung (Capturing)]

.blockquote[Rückbezüge (Backreferences)]

.blockquote[Mustererkennung mit Unicode]

---
class: left

.blockquote[Erfassung (Capturing)]

##  Gruppierung von Teilmustern

* Dient der *Gruppierung von Teilen* von Mustern
* Erfasste Teile (von Mustern) können in darauffolgenden Schritten referenziert werden.

.pull-left[

```r
ANY_CHAR %R% "a"
```

```
## <regex> .a
```
]
--
.pull-right[

```r
str_extract(c("Fakten","Katzen"),
            pattern=ANY_CHAR %R% "a")
```

```
## [1] "Fa" "Ka"
```
]
--

.pull-left[

* Erfasste Teile (*captured groups*) werden in regulären Ausdrücken durch `()` angezeigt/eingegeben:

```r
capture(ANY_CHAR) %R% "a"
```

```
## <regex> (.)a
```
]
--
.pull-right[
* Capturing führt vordergründig (!) zum selben Ergebnis:

```r
str_extract(c("Fakten","Katzen"),
            capture(ANY_CHAR) %R% "a")
```

```
## [1] "Fa" "Ka"
```
]

???

* Capturing ändert nicht das Muster, das abgeglichen wird, entsprechend führt es auch zum selben Ergebnis
* Aber: capturing zeigt an, dass wir (in darauffolgenden Schritten) etwas mit dem erfassten Muster machen wollen

---
class: left

.blockquote[Erfassung (Capturing)]

##  Verwendung erfasster Teilmuster

* Verwendung in `str_match()` liefert eine Matrix, wobei die...
  * ...erste Spalte  dem Ergebnis von `str_extract()` entspricht.
  * ...zweite Spalte  nur den erfassten Teil des Musters enthält.

* Beispiel

```r
str_match(c("Fakten","Katze"), pattern=capture(ANY_CHAR) %R% "a")
```

```
##      [,1] [,2]
## [1,] "Fa" "F" 
## [2,] "Ka" "K"
```

???

* Verwendung in `str_match()` liefert eine Matrix
  * erste Spalte entspricht dem Ergebnis von `str_extract()` **mit dem exakten Match**
  * die zweite Spalte enthält dagegen nur den erfassten Teil des Musters in der captured group

---
class: left

.blockquote[Erfassung (Capturing)]

##  Anwendungsbeispiel mit erfassten Gruppen

* Beispiel: Dollar-Beträge unter 100$

```r
muster <- DOLLAR %R% DGT %R% optional(DGT) %R% DOT %R% dgt(2)
str_view(c("$7.70","$27.00"),pattern = muster)
```

```
## [1] │ <$7.70>
## [2] │ <$27.00>
```

* Nutzung erfasster Teilmuster zur getrennten Extraktion von Dollar- und Cent-Beträgen:

```r
cap_muster <- DOLLAR %R% capture(DGT %R% optional(DGT)) %R% DOT %R% capture(dgt(2))
str_match(c("$7.70","$27.00"), pattern = cap_muster)
```

```
##      [,1]     [,2] [,3]
## [1,] "$7.70"  "7"  "70"
## [2,] "$27.00" "27" "00"
```

???

* Obs! capture-Funktion wird zweimal verwendet:
  * einmal um die Vorkommastelle(n) und 
  * einmal um die Nachkommastellen

---
class: left

.blockquote[Rückbezüge (Backreferences)]

## Verweis auf erfasste Teile von Mustern

```r
REF1
```

```
## <regex> \1
```

```r
REF2
```

```
## <regex> \2
```

---
class: left

.blockquote[Mustererkennung mit Unicode]

## Unicode

---
class: inverse,center,middle

# Wir brauchen eine Pause.

---

background-image: url("data:image/png;base64,#http://bit.ly/cs631-donkey")
background-size: 80%

---
class: left

## Quellenverzeichnis

.ref-slide[
<a name=bib-wickham_r_2023></a>[Wickham, H., M. Çetinkaya-Rundel, and
G. Grolemund](#cite-wickham_r_2023) (2023). _R for Data Science:
Import, Tidy, Transform, Visualize, and Model Data_. 2nd Edition.
Beijing Boston Farnham Sebastopol Tokyo: O'Reilly. ISBN:
978-1-4920-9740-2.
]